import config from '../../focus.config.js';
import http from './http.js';
import sign from './sign.js';
import showToast from './showToast.js';
import { showLoading, hideLoading } from './loading.js';
import toJson from '../data/toJson.js';
import runtimeType from '../sys/runtimeType.js';

/**
 * upload资源上传【异步方法】
 * @description upload资源上传，参数详情请查看配置文件focus.config.js
 * @param {Object} parameter 方法参数
 */
function upload(parameter) {
	
	// ------------------------------------------------ 参数预处理
    // 获取当前运行环境
    var runType = runtimeType();
	// 获取配置文件upload信息
	var config_upload = config.upload;
	// 合并方法参数
	var paramLast = Object.assign({}, config_upload, parameter);
	// 成品请求地址 = 请求地址头 + api地址
	if (paramLast["openHttphead"] == true) { paramLast["url"] = http('get') + paramLast["url"]; }
	// 初次显示"请求中"提示弹框
	showLoading(paramLast, 0);
	
	// ------------------------------------------------ header请求头
	// 要传递请求头 编辑
	var req_header = {};
    // 1. 添加content-type
    // req_header['Content-Type'] = 'multipart/form-data';
    // 2. 配置文件header加入到此数据
    if (config_upload["header"]) { for (var key in config_upload["header"]) { req_header[key] = config_upload.header[key]; } }
    // 3. 主动传递参数的header覆盖到此数据
    if (paramLast["header"]) { for (var key in paramLast["header"]) { req_header[key] = paramLast.header[key]; } }
	/** 添加token鉴权
	 * 数据示例：{ "Authorization": 'Bearer ' + 'AD7TGQW98WQFW-D273D87-238G' }
	 * */
	
	// ------------------------------------------------ 传输数据签名
	// 调用生成签名方法
	if (paramLast["openSign"] == true) { paramLast["data"] = sign(paramLast["data"]); }
	
	// ------------------------------------------------ 地址栏传输数据
	// 请求地址取出
	var str_url_api = paramLast["url"];
	// 地址栏数据添加
	for (var key in paramLast["urlData"]) { str_url_api += '/' + encodeURIComponent(paramLast.urlData[key]); }
	
	// ------------------------------------------------ 上传进度初始化
	// 总需要的进度 = 100% * 上传文件数量
	var num_progress_total = Math.round(100 * paramLast["files"].length);
	// 保存表：各文件上传进度
	var arr_progress_file = [];
	
	// ------------------------------------------------ 循环待上传文件列表
	// 循环要上传的文件
	for (var i = 0; i < paramLast["files"].length; i++)
	{
		// 节点 - 一个文件信息对象
		let ele_file = paramLast["files"][i];
		// 初始化此文件的上传进度
		let num_index = parseInt(i);
		arr_progress_file[num_index] = 0;
		
        // ------------------------------------------------ 调用上传请求api
        // 如果是“非UNI”环境
        // if (runType == 'nonUNI')
        // {
        //     // 创建  XMLHttpRequest 对象
        //     let xmlhttp = {};
        //     if (window.XMLHttpRequest) { xmlhttp = new XMLHttpRequest(); }
        //     else { xmlhttp = new ActiveXObject("Microsoft.XMLHTTP"); }
            
        //     // 超时限制
        //     var timeout = setTimeout(()=>{
        //         // 终止请求
        //     	xmlhttp.abort();
        //         // 组装返回数据
        //     	var data_back = { code: 408, data: {}, msg: "请求超时" };
        //         // 取消loading弹框
        //         hideLoading(paramLast);
        //         // 显示提示框
        //         showToast(paramLast, data_back.msg);
        //         // 配置文件失败方法
        //         if (config_upload && config_upload.fail) { config_upload.fail(data_back); }
        //         // 主动参数的失败方法
        //         if (parameter && parameter.fail) { parameter.fail(data_back); }
        //     }, paramLast["timeout"]);
            
        //     // 要发送的数据封装(上传数据表单化处理)
        //     let myform = new FormData();
        //     myform.append(ele_file["name"], ele_file["path"]);
        //     // 上传进度回调
        //     xmlhttp.upload.onprogress = (ev) => {
        //     	// 检测是否真实上传
        //     	if (ev.lengthComputable) 
        //     	{
        //             // 此文件上传进度 赋值
        //             arr_progress_file[num_index] = Math.floor(ev.loaded / ev.total * 1000) / 10; // 百分比，如： 53.8
        //             // 已经完成的上传进度
        //             var num_progress_files = 0;
        //             // 各文件上传进度求和
        //             arr_progress_file.forEach((val)=>{
        //             	// 向小取整，防止提前100%
        //             	num_progress_files = Math.floor(num_progress_files + val);
        //             });
        //             // 计算当前已有的上传进度
        //             var num_progress_already = Math.floor(num_progress_files / num_progress_total * 100);
        //             // 进度显示框
        //             showLoading(paramLast, num_progress_already);
        //             // 传回给监听方法的数据
        //             var backThis = {
        //             	percentage: num_progress_already, // 总上传进度百分比
        //             };
        //             // 配置文件监听回调
        //             if (config_upload && config_upload.progress) { config_upload.progress(backThis); }
        //             // 主动参数的监听回调
        //             if (parameter && parameter.progress) { parameter.progress(backThis); }
        //     	}
        //     };
            
        //     // 请求设置
        //     xmlhttp.open("POST", str_url_api, true); // 请求方式和地址
        //     for (var k in req_header) { xmlhttp.setRequestHeader(k, req_header[k]); } // 请求头数据赋值
        //     // xmlhttp.withCredentials = true;
            
        //     // 服务器响应
        //     xmlhttp.onreadystatechange = () => {
        //     	// 链接接口成功
        //     	if (xmlhttp.readyState == 4 && xmlhttp.status == 200)
        //     	{
        //     		// 取消超时限制
        //             if (timeout) { clearTimeout(timeout); }
        //             // 后端返回的原始字符串数据
        //             var str_response = "";
        //             if (xmlhttp.responseText) { str_response = xmlhttp.responseText; }
        //             else if (xmlhttp.responseXML) { str_response = xmlhttp.responseXML; }
        //             // 将数据转换为json
        //             var obj_response = toJson(str_response);
        //             // 取消loading弹框
        //             hideLoading(paramLast);
        //             // 如果数据转换失败了
        //             if (!obj_response)
        //             {
        //                 // 错误提示
        //                 showToast(paramLast, '返回数据格式错误');
        //                 // 配置文件失败方法
        //                 if (config_upload && config_upload.fail) { config_upload.fail(obj_response); }
        //                 // 主动参数的失败方法
        //                 if (parameter && parameter.fail) { parameter.fail(obj_response); }
        //             }
        //             // 如果成功code码与规定不符
        //             else if (obj_response.code != paramLast['successCode'])
        //             {
        //             	// 错误提示
        //             	showToast(paramLast, obj_response.msg);
        //                 // 配置文件失败方法
        //                 if (config_upload && config_upload.fail) { config_upload.fail(obj_response); }
        //                 // 主动参数的失败方法
        //                 if (parameter && parameter.fail) { parameter.fail(obj_response); }
        //             }
        //             // 成功回调
        //             else {
        //                 // 配置文件成功方法
        //                 if (config_upload && config_upload.success) { config_upload.success(obj_response.data); }
        //                 // 主动参数的成功方法
        //                 if (parameter && parameter.success) { parameter.success(obj_response.data); }
        //             }
        //         }
        //     	// 链接接口失败
        //     	else if (xmlhttp.readyState == 4)
        //     	{
        //     		// 取消超时限制
        //     		if (timeout) { clearTimeout(timeout); }
        //     		// 组装返回数据
        //     		var resD = {
        //     		    code: xmlhttp.status ? xmlhttp.status : 400,
        //     		    data: null,
        //     		    msg: xmlhttp.responseText ? xmlhttp.responseText : null,
        //     		};
        //             // 取消loading弹框
        //             hideLoading(paramLast);
        //             // 错误提示
        //             showToast(paramLast, '抱歉，数据请求异常 ' + resD.code);
        //             // 配置文件失败方法
        //             if (config_upload && config_upload.fail) { config_upload.fail(resD); }
        //             // 主动参数的失败方法
        //             if (parameter && parameter.fail) { parameter.fail(resD); }
        //     	}
        //     };
            
        //     // 发送请求
        //     xmlhttp.send(myform);
        // }
        // 如果是UNI环境
        // else {
            // 官方发起上传api
            let uploadTask = uni.uploadFile({
            	url: str_url_api,
            	fileType: paramLast["fileType"],
            	name: ele_file["name"],
            	filePath: ele_file["path"],
            	formData: paramLast["data"],
            	header: req_header,
            	timeout: paramLast["timeout"],
            	fail: (resD) => {
            		// 取消loading弹框
            		hideLoading(paramLast);
            		// 显示提示框 此处数据为框架系统返回数据，所以是errMsg
            		showToast(paramLast, resD.errMsg);
                    // 配置文件失败方法
                    if (config_upload && config_upload.fail) { config_upload.fail(resD); }
                    // 主动参数的失败方法
                    if (parameter && parameter.fail) { parameter.fail(resD); }
            	},
            	success: (resD) => {
            		// 转换数据
            		resD.data = toJson(resD.data);
            		// 取消loading弹框
            		hideLoading(paramLast);
            		// 如果是状态码错误
            		if (resD.statusCode != 200)
            		{
            			// 错误提示
            			showToast(paramLast, '抱歉，数据请求异常 ' + resD.statusCode);
                        // 配置文件失败方法
                        if (config_upload && config_upload.fail) { config_upload.fail(resD.data); }
                        // 主动参数的失败方法
                        if (parameter && parameter.fail) { parameter.fail(resD.data); }
            		}
            		// 如果成功code码与规定不符
            		else if (resD.data.code != paramLast['successCode'])
            		{
            			// 错误提示
            			showToast(paramLast, resD.data.msg);
                        // 配置文件失败方法
                        if (config_upload && config_upload.fail) { config_upload.fail(resD.data); }
                        // 主动参数的失败方法
                        if (parameter && parameter.fail) { parameter.fail(resD.data); }
            		}
            		// 成功回调
            		else {
                        // 配置文件成功方法
                        if (config_upload && config_upload.success) { config_upload.success(resD.data.data); }
                        // 主动参数的成功方法
                        if (parameter && parameter.success) { parameter.success(resD.data.data); }
                    }
            	},
            });
            // 上传进度监听
            uploadTask.onProgressUpdate((TaskD) => {
            	// 此文件上传进度 赋值
            	arr_progress_file[num_index] = TaskD.progress;
            	// 已经完成的上传进度
            	var num_progress_files = 0;
            	// 各文件上传进度求和
            	arr_progress_file.forEach((val)=>{
            		// 向小取整，防止提前100%
            		num_progress_files = Math.floor(num_progress_files + val);
            	});
            	// 计算当前已有的上传进度
            	var num_progress_already = Math.floor(num_progress_files / num_progress_total * 100); 
            	// 进度显示框
            	showLoading(paramLast, num_progress_already);
            	// 传回给监听方法的数据
            	var backThis = {
            		percentage: num_progress_already, // 总上传进度百分比
            	};
                // 配置文件监听回调
                if (config_upload && config_upload.progress) { config_upload.progress(backThis); }
                // 主动参数的监听回调
                if (parameter && parameter.progress) { parameter.progress(backThis); }
            });
        // }
        
	}
	
}

export default upload;